home *** CD-ROM | disk | FTP | other *** search
/ Aminet 45 / Aminet 45 (2001)(GTI - Schatztruhe)[!][Oct 2001].iso / Aminet / dev / gui / FoxGuiSource.lha / FoxLibSource / TreeControl.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-07-08  |  36.7 KB  |  1,212 lines
  1. /* FoxGUI - The fast, flexible, free Amiga GUI system
  2.     Copyright (C) 2001 Simon Fox (Foxysoft)
  3.  
  4. This library is free software; you can redistribute it and/or
  5. modify it under the terms of the GNU Lesser General Public
  6. License as published by the Free Software Foundation; either
  7. version 2.1 of the License, or (at your option) any later version.
  8.  
  9. This library is distributed in the hope that it will be useful,
  10. but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12. Lesser General Public License for more details.
  13.  
  14. You should have received a copy of the GNU Lesser General Public
  15. License along with this library; if not, write to the Free Software
  16. Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17. Foxysoft: www.foxysoft.co.uk      Email:simon@foxysoft.co.uk                */
  18.  
  19. /******************************************************************************
  20.  * Shared library code.  Cannot call functions which use exit() such as:
  21.  * printf(), fprintf()
  22.  *
  23.  * Otherwise:
  24.  * The linker returns "__XCEXIT undefined" and the program will fail.
  25.  * This is because you must not exit() a library!
  26.  *
  27.  * Also:
  28.  * proto/exec.h must be included instead of clib/exec_protos.h and
  29.  * __USE_SYSBASE must be defined.
  30.  *
  31.  * Otherwise:
  32.  * The linker returns "Absolute reference to symbol _SysBase" and the
  33.  * library crashes.  Presumably the same is true for the other protos.
  34.  ******************************************************************************/
  35.  
  36. #define __USE_SYSBASE
  37.  
  38. #include <proto/mathieeedoubbas.h>
  39. #include <stdio.h>
  40. #include <stdlib.h>
  41. #include <stdarg.h>
  42. #include <string.h>
  43. #include <math.h>
  44.  
  45. #include <proto/graphics.h>
  46. #include <proto/intuition.h>
  47. #include "/FoxInclude/FoxGui.h"
  48.  
  49. #include "FoxGuiTools.h"
  50.  
  51. #define XOFFSET 10
  52. #define PLUSMINUSBUTTONWIDTH    11
  53. #define SCROLL_BUTTON_WIDTH        16
  54. #define SCROLL_BUTTON_HEIGHT    10
  55.  
  56. __far __stdargs int PlusMinusButtonFn(PushButton *pb);
  57.  
  58. static __inline __regargs void TreeControlClipOn(TreeControl *tc)
  59. {
  60.     if (tc && !(tc->WidgetData->flags & LB_CLIPPED))
  61.     {
  62.         struct Region *rg;
  63.         int llborder = tc->WidgetData->left + tc->LBorder + 2;
  64.         int left = llborder, right = tc->WidgetData->left + tc->points[0] - tc->LBorder - 2;
  65.  
  66.         rg = ClipGuiWindow(tc->Win, left, tc->WidgetData->top + tc->TBorder + 2,
  67.                 right, tc->WidgetData->top + tc->WidgetData->height - (tc->LR ? SCROLL_BUTTON_HEIGHT : 0) - tc->TBorder - 3);
  68.         if (rg)
  69.             DisposeRegion(rg);
  70.         tc->WidgetData->flags |= LB_CLIPPED;
  71.     }
  72. }
  73.  
  74. static __inline __regargs void TreeControlClipOff(TreeControl *tc)
  75. {
  76.     if (tc && tc->WidgetData->flags & LB_CLIPPED)
  77.     {
  78.         UnclipGuiWindow(tc->Win);
  79.         tc->WidgetData->flags &= ~LB_CLIPPED;
  80.     }
  81. }
  82.  
  83. static int DrawTreeItem(TreeItem *ti, int top, BOOL recurse, BOOL undraw)
  84. {
  85.     if (ti)
  86.     {
  87.         // Draw line to parent.  Even if the item itself is outside
  88.         // the current view, the line may still pass through it.
  89.         if (ti->parent)
  90.         {
  91.             if (undraw)
  92.                 ti->LineToParent.FrontPen = ti->treecontrol->Win->Win->RPort->BgPen;
  93.             else
  94.             {
  95.                 ti->LineToParent.FrontPen = ti->treecontrol->FrontPen;
  96.                 ti->points[0] = ti->points[2] = ti->parent->it.LeftEdge + (short) floor(PLUSMINUSBUTTONWIDTH / 2.0) + 1;
  97.                 ti->points[1] = CalcItemTop(ti->parent) + ti->it.ITextFont->ta_YSize;
  98.                 ti->points[3] = ti->points[5] = top + (ti->it.ITextFont->ta_YSize / 2);
  99.                 ti->points[4] = ti->it.LeftEdge;
  100.             }
  101.             DrawBorder(ti->treecontrol->Win->Win->RPort, &ti->LineToParent, ti->treecontrol->WidgetData->left + ti->treecontrol->xOffset, ti->treecontrol->WidgetData->top);
  102.         }
  103.  
  104.         // Only draw the item if it is in the visible area of the tree
  105.         // control even though the area is clipped (it will reduce time).
  106.         if (top + ti->it.ITextFont->ta_YSize < ti->treecontrol->WidgetData->height - 4 - (2 * ti->treecontrol->TBorder)
  107.                 - (ti->treecontrol->LR ? SCROLL_BUTTON_HEIGHT : 0) && top >= 0)
  108.         {
  109.             int PenStore;
  110.             if (undraw)
  111.             {
  112.                 PenStore = ti->it.FrontPen;
  113.                 ti->it.FrontPen = ti->treecontrol->Win->Win->RPort->BgPen;
  114.                 if (ti->plusminus)
  115.                 {
  116.                     ti->plusminus->WidgetData->ParentControl = NULL;
  117.                     Destroy(ti->plusminus, TRUE);
  118.                     ti->plusminus = NULL;
  119.                 }
  120.                 if (ti == ti->treecontrol->hiitem)
  121.                     AreaColFill(ti->treecontrol->Win->Win->RPort, ti->treecontrol->WidgetData->left + 2 +
  122.                             ti->treecontrol->LBorder + (ti->bmi ? ti->bm->width : 0) +
  123.                             (ti->firstchild ? PLUSMINUSBUTTONWIDTH + 2 : 0) + ti->treecontrol->xOffset +
  124.                             ti->it.LeftEdge, top + ti->treecontrol->WidgetData->top + 2 + ti->treecontrol->TBorder +
  125.                             ti->it.TopEdge, IntuiTextLength(&ti->it), ti->treecontrol->Font->ta_YSize,
  126.                             GetBackCol(ti->treecontrol->WidgetData->Parent));
  127.                 if (ti->bmi)
  128.                 {
  129.                     HideBitMap(ti->bmi);
  130.                     ti->bmi = NULL;
  131.                 }
  132.             }
  133.             else
  134.             {
  135.                 if (ti->firstchild)
  136.                 {
  137.                     if (ti->plusminus && ti->plusminus->button.LeftEdge == ti->treecontrol->WidgetData->left + 2 +
  138.                             ti->treecontrol->LBorder + ti->it.LeftEdge && ti->plusminus->button.TopEdge ==
  139.                             top + ti->treecontrol->WidgetData->top + 2 + ti->treecontrol->TBorder)
  140.                         RefreshGList(&ti->plusminus->button, ti->treecontrol->Win->Win, NULL, 1L);
  141.                     else if (ti->plusminus)
  142.                     {
  143.                         ti->plusminus->WidgetData->ParentControl = NULL;
  144.                         DestroyButton(ti->plusminus, FALSE);
  145.                         ti->plusminus = NULL;
  146.                     }
  147.                     if (ti->treecontrol->xOffset + ti->it.LeftEdge >= 0 && !ti->plusminus)
  148.                     {
  149.                         ti->plusminus = MakeButton(ti->treecontrol->Win, "", ti->treecontrol->xOffset +
  150.                             ti->treecontrol->WidgetData->left + 2 + ti->treecontrol->LBorder + ti->it.LeftEdge,
  151.                             top + ti->treecontrol->WidgetData->top + 2 + ti->treecontrol->TBorder,
  152.                             PLUSMINUSBUTTONWIDTH, ti->it.ITextFont->ta_YSize,
  153.                             ((ti->flags & TI_OPEN) ? '-' : '+'),
  154.                             ((ti->flags & TI_OPEN) ? &ti->treecontrol->minus : &ti->treecontrol->plus),
  155.                             PlusMinusButtonFn, BN_STD | BN_CLEAR | THREED, NULL);
  156.                         if (ti->plusminus)
  157.                             ti->plusminus->WidgetData->ParentControl = (Widget *) ti;
  158.                     }
  159.                 }
  160.                 if (ti->bm && !ti->bmi)
  161.                     ti->bmi = ShowBitMap(ti->bm, ti->treecontrol->Win, (unsigned short)
  162.                         (ti->treecontrol->xOffset + ti->treecontrol->WidgetData->left + 2 + ti->treecontrol->LBorder +
  163.                         ti->it.LeftEdge + (ti->firstchild ? PLUSMINUSBUTTONWIDTH + 2 : 0)),
  164.                         (unsigned short) (top + ti->treecontrol->WidgetData->top + 2 + ti->treecontrol->TBorder),
  165.                         ti->bm->flags);
  166.                 if (ti == ti->treecontrol->hiitem)
  167.                     AreaColFill(ti->treecontrol->Win->Win->RPort, ti->treecontrol->WidgetData->left + 2 +
  168.                             ti->treecontrol->LBorder + (ti->bm ? ti->bm->width : 0) +
  169.                             (ti->firstchild ? PLUSMINUSBUTTONWIDTH + 2 : 0) + ti->treecontrol->xOffset +
  170.                             ti->it.LeftEdge, top + ti->treecontrol->WidgetData->top + 2 + ti->treecontrol->TBorder +
  171.                             ti->it.TopEdge, IntuiTextLength(&ti->it), ti->treecontrol->Font->ta_YSize,
  172.                             ti->treecontrol->FrontPen);
  173.             }
  174.             PrintIText(ti->treecontrol->Win->Win->RPort, &ti->it, ti->treecontrol->WidgetData->left + 2 +
  175.                 ti->treecontrol->LBorder + (ti->bm ? ti->bm->width : 0) +
  176.                 (ti->firstchild ? PLUSMINUSBUTTONWIDTH + 2 : 0) + ti->treecontrol->xOffset,
  177.                 top + ti->treecontrol->WidgetData->top + 2 + ti->treecontrol->TBorder);
  178.             if (undraw)
  179.                 ti->it.FrontPen = PenStore;
  180.         }
  181.         if (ti->firstchild && (ti->flags & TI_OPEN) && recurse)
  182.             top = DrawTreeItem(ti->firstchild, top + ti->it.ITextFont->ta_YSize, recurse, undraw);
  183.         if (ti->next && recurse)
  184.             top = DrawTreeItem(ti->next, top + ti->it.ITextFont->ta_YSize, recurse, undraw);
  185.     }
  186.     return top;
  187. }
  188.  
  189. /* Returns TRUE if an item is visibly open (i.e. it's parent
  190. and it's parents parent etc must also be open) */
  191. BOOL FOXLIB ItemIsOpen(REGA0 TreeItem *it)
  192. {
  193.     if (!(it->flags & TI_OPEN))
  194.         return FALSE;
  195.     else if (it->parent)
  196.         return ItemIsOpen(it->parent);
  197.     else
  198.         return TRUE;
  199. }
  200.  
  201. int TCScrollUpButtFn(PushButton *pb);
  202. int TCScrollDownButtFn(PushButton *pb);
  203. int TCScrollLeftButtFn(PushButton *pb);
  204. int TCScrollRightButtFn(PushButton *pb);
  205.  
  206. static void CheckCreateScrollers(TreeControl *tc)
  207. {
  208.     int top = 0, maxtop = 0, maxlen = 0;
  209.     BOOL created = FALSE;
  210.     FindMaxSizes(tc->itemlist, &maxlen, &maxtop, &top);
  211.  
  212.     if (maxtop + tc->Font->ta_YSize > tc->WidgetData->height - (tc->LR ? SCROLL_BUTTON_HEIGHT : 0) - 4 -
  213.             (2 * tc->TBorder) && !tc->UD)
  214.     {
  215.         TreeControlClipOn(tc);
  216.         DrawTreeItem(tc->itemlist, CalcItemTop(tc->itemlist), TRUE, TRUE); // Undraw
  217.         TreeControlClipOff(tc);
  218.         MakeVerticalScroller(tc, TCScrollUpButtFn, TCScrollDownButtFn);
  219.         created = TRUE;
  220.         if (tc->UD)
  221.         {
  222.             tc->WidgetData->flags |= SYS_LB_VSCROLL;
  223.             ResizeListBox(tc, tc->WidgetData->left, tc->WidgetData->top, tc->WidgetData->width, tc->WidgetData->height, (double) 1.0, (double) 1.0, TRUE);
  224.             if (tc->hidden == 0)
  225.             {
  226.                 AddGadget(tc->Win->Win, &tc->UD->ScrollGad, ~0);
  227.                 RefreshGList(&tc->UD->ScrollGad, tc->Win->Win, NULL, 1);
  228.             }
  229.             if (!tc->Enabled)
  230.                 DisableScroller(tc->UD);
  231.         }
  232.     }
  233.     if (maxlen > tc->WidgetData->width - (tc->UD ? SCROLL_BUTTON_WIDTH : 0) - 4 - (2 * tc->LBorder) && !tc->LR)
  234.     {
  235.         tc->WidgetData->flags |= SYS_LB_HSCROLL;
  236.         if (!created)
  237.         {
  238.             TreeControlClipOn(tc);
  239.             DrawTreeItem(tc->itemlist, CalcItemTop(tc->itemlist), TRUE, TRUE); // Undraw
  240.             TreeControlClipOff(tc);
  241.         }
  242.         MakeHorizontalScroller(tc, TCScrollLeftButtFn, TCScrollRightButtFn);
  243.         created = TRUE;
  244.         ResizeListBox(tc, tc->WidgetData->left, tc->WidgetData->top, tc->WidgetData->width, tc->WidgetData->height, (double) 1.0, (double) 1.0, TRUE);
  245.         if (maxtop + tc->Font->ta_YSize > tc->WidgetData->height - SCROLL_BUTTON_HEIGHT - 4 -
  246.                 (2 * tc->TBorder) && !tc->UD)
  247.         {
  248.             MakeVerticalScroller(tc, TCScrollUpButtFn, TCScrollDownButtFn);
  249.             if (tc->UD)
  250.             {
  251.                 tc->WidgetData->flags |= SYS_LB_VSCROLL;
  252.                 ResizeListBox(tc, tc->WidgetData->left, tc->WidgetData->top, tc->WidgetData->width, tc->WidgetData->height, (double) 1.0, (double) 1.0, TRUE);
  253.                 if (tc->hidden == 0)
  254.                 {
  255.                     AddGadget(tc->Win->Win, &tc->UD->ScrollGad, ~0);
  256.                     RefreshGList(&tc->UD->ScrollGad, tc->Win->Win, NULL, 1);
  257.                 }
  258.                 if (!tc->Enabled)
  259.                     DisableScroller(tc->UD);
  260.             }
  261.         }
  262.     }
  263.     if (created)
  264.     {
  265.         ListBoxRefresh(tc);
  266.         TreeControlClipOn(tc);
  267.         DrawTreeItem(tc->itemlist, CalcItemTop(tc->itemlist), TRUE, FALSE);
  268.         TreeControlClipOff(tc);
  269.     }
  270.     if (tc->UD)
  271.     {
  272.         unsigned short body, pot;
  273.  
  274.         FindScrollerValues((maxtop + tc->Font->ta_YSize) / tc->Font->ta_YSize, (tc->WidgetData->height - 4 - (2 * tc->TBorder) - (tc->LR ? SCROLL_BUTTON_HEIGHT : 0)) / tc->Font->ta_YSize, (0 - CalcItemTop(tc->itemlist)) / tc->Font->ta_YSize, 1, &body, &pot);
  275.         NewModifyProp(&tc->UD->ScrollGad, tc->Win->Win, NULL, AUTOKNOB | FREEVERT | PROPNEWLOOK, 0, pot, 0, body, 1);
  276.     }
  277.     if (tc->LR)
  278.     {
  279.         unsigned short body, pot;
  280.  
  281.         FindScrollerValues(maxlen, tc->WidgetData->width - 4 - (2 * tc->LBorder) - (tc->UD ? SCROLL_BUTTON_WIDTH : 0), 0 - tc->xOffset, tc->Font->ta_YSize, &body, &pot);
  282.         NewModifyProp(&tc->LR->ScrollGad, tc->Win->Win, NULL, AUTOKNOB | FREEHORIZ | PROPNEWLOOK, pot, 0, body, 0, 1);
  283.     }
  284. }
  285.  
  286. static void CheckDestroyScrollers(TreeControl *tc)
  287. {
  288.     int top = 0, maxtop = 0, maxlen = 0;
  289.     BOOL destroyed = FALSE;
  290.     FindMaxSizes(tc->itemlist, &maxlen, &maxtop, &top);
  291.  
  292.     if (maxlen < tc->WidgetData->width - (tc->UD ? SCROLL_BUTTON_WIDTH : 0) && tc->LR)
  293.     {
  294.         TreeControlClipOn(tc);
  295.         DrawTreeItem(tc->itemlist, CalcItemTop(tc->itemlist), TRUE, TRUE);
  296.         TreeControlClipOff(tc);
  297.         DestroyHorizontalScroller(tc, TRUE);
  298.         destroyed = TRUE;
  299.     }
  300.     if (maxtop + tc->Font->ta_YSize < tc->WidgetData->height - (tc->LR ? SCROLL_BUTTON_HEIGHT : 0) && tc->UD)
  301.     {
  302.         if (!destroyed)
  303.         {
  304.             TreeControlClipOn(tc);
  305.             DrawTreeItem(tc->itemlist, CalcItemTop(tc->itemlist), TRUE, TRUE);
  306.             TreeControlClipOff(tc);
  307.         }
  308.         DestroyVerticalScroller(tc, TRUE);
  309.         // We may have just closed a +/- button and therefore no-longer need a scroller BUT that
  310.         // doesn't necessarily mean that topshown is currently itemlist.  It should be now.
  311.         tc->topshown = tc->itemlist;
  312.  
  313.         if (maxlen < tc->WidgetData->width && tc->LR)
  314.             DestroyHorizontalScroller(tc, TRUE);
  315.         destroyed = TRUE;
  316.     }
  317.     if (destroyed)
  318.     {
  319.         TreeControlClipOn(tc);
  320.         DrawTreeItem(tc->itemlist, CalcItemTop(tc->itemlist), TRUE, FALSE);
  321.         TreeControlClipOff(tc);
  322.     }
  323. }
  324.  
  325. static TreeItem *FindTreeItemRecurse(TreeItem *root, char *text)
  326. {
  327.     TreeItem *found = NULL;
  328.  
  329.     if (strcmp(root->it.IText, text) == 0)
  330.         return root;
  331.     if (root->firstchild)
  332.         found = FindTreeItemRecurse(root->firstchild, text);
  333.     if (root->next && !found)
  334.         found = FindTreeItemRecurse(root->next, text);
  335.     return found;
  336. }
  337.  
  338. TreeItem* FOXLIB FindTreeItem(REGA0 TreeControl *tc, REGA1 char *text)
  339. {
  340.     return FindTreeItemRecurse(tc->itemlist, text);
  341. }
  342.  
  343. void FOXLIB RemoveItem(REGA0 TreeItem *ti)
  344. {
  345.     TreeControl *tc = ti->treecontrol;
  346.     TreeItem *pp = ti, *redrawfrom = NULL, *previous = NULL, *oldtopshown = tc->topshown;
  347.  
  348.     if (ti->parent)
  349.     {
  350.         BOOL parentopen = ItemIsOpen(ti->parent);
  351.         if (parentopen)
  352.         {
  353.             while (pp->parent)
  354.                 pp = pp->parent;
  355.             TreeControlClipOn(tc);
  356.             DrawTreeItem(pp, CalcItemTop(pp), TRUE, TRUE);
  357.         }
  358.  
  359.         if (ti->parent->firstchild == ti)
  360.             ti->parent->firstchild = ti->next;
  361.         else
  362.         {
  363.             TreeItem *t = ti->parent->firstchild, *p = NULL;
  364.  
  365.             while (t != ti)
  366.             {
  367.                 p = t;
  368.                 t = t->next;
  369.             }
  370.             previous = p;
  371.         }
  372.  
  373.         if (ti == tc->hiitem)
  374.             tc->hiitem = NULL;
  375.  
  376.         if (parentopen)
  377.             redrawfrom = pp;
  378.     }
  379.     else
  380.     {
  381.         TreeControlClipOn(tc);
  382.         DrawTreeItem(ti, CalcItemTop(ti), TRUE, TRUE);
  383.  
  384.         if (ti != tc->itemlist)
  385.         {
  386.             TreeItem *t = tc->itemlist, *p = NULL;
  387.  
  388.             while (t != ti)
  389.             {
  390.                 p = t;
  391.                 t = t->next;
  392.             }
  393.             previous = p;
  394.         }
  395.  
  396.         if (ti == tc->hiitem)
  397.             tc->hiitem = NULL;
  398.  
  399.         redrawfrom = ti->next;
  400.     }
  401.  
  402.     // Now free the item and any children
  403.     if (ti->firstchild)
  404.         FreeItemTree(ti->firstchild, ti, TRUE);
  405.     if (previous)
  406.         previous->next = ti->next;
  407.     if (ti == tc->itemlist)
  408.         tc->itemlist = ti->next;
  409.     if (ti->it.IText)
  410.         GuiFree(ti->it.IText);
  411.     if (ti->bm && (ti->flags & TI_BITMAPISSCALED))
  412.         FreeGuiBitMap(ti->bm);
  413.     if (tc->topshown == ti || tc->topshown == NULL) // FreeItemTree may have set this to NULL
  414.         if (ti->next)
  415.             tc->topshown = ti->next;
  416.         else if (tc->itemlist)
  417.             tc->topshown = FindPreviousItem(ti);
  418.         else
  419.             tc->topshown = NULL;
  420.  
  421.     CheckDestroyScrollers(tc);
  422.  
  423.     GuiFree(ti);
  424.  
  425.     if (redrawfrom)
  426.     {
  427.         if (tc->topshown != oldtopshown)
  428.             redrawfrom = tc->topshown;
  429.         DrawTreeItem(redrawfrom, CalcItemTop(redrawfrom), TRUE, FALSE);
  430.     }
  431.     TreeControlClipOff(tc);
  432. }
  433.  
  434. TreeItem* FOXLIB ReplaceTCItem(REGA0 TreeItem *old, REGA1 char *text, REGA2 GuiBitMap *bm, REGA3 void *ItemData)
  435. {
  436.     if (old)
  437.     {
  438.         char *oldIText = old->it.IText;
  439.         int top = CalcItemTop(old);
  440.  
  441.         TreeControlClipOn(old->treecontrol);
  442.         if ((!(old->parent)) || ItemIsOpen(old->parent))
  443.             DrawTreeItem(old, top, FALSE, TRUE);
  444.  
  445.         if (old->bmi)
  446.             GuiFree(old->bmi);
  447.         // Don't free the bitmap unless we allocated a copy - otherwise the user allocated it and should free
  448.         //    it.  In this way, the user can use the same bitmap for many items in the list.
  449.         if (old->bm && (old->flags & TI_BITMAPISSCALED))
  450.             FreeGuiBitMap(old->bm);
  451.         if (old->flags & TI_BITMAPISSCALED)
  452.             old->flags &= ~TI_BITMAPISSCALED;
  453.  
  454.         old->bm = bm;
  455.         if (old->bm && old->bm->height > old->treecontrol->Font->ta_YSize)
  456.         {
  457.             /* The compiler should be clever enough to know that we're using Commodore IEEE DP Maths and insert all of the necessary
  458.                 conversions at compile time.  However, it can't manage the conversion from IEEE DP to unsigned short on it's own without
  459.                 generating a reference to __XCEXIT which we just can't allow in a shared library so I've helped it along a bit by inserting
  460.                 some of the conversions.  See Includes & Autodocs for a description of the IEEE DP conversions in the mathieeedoubbas
  461.                 library */
  462.             old->bm = ScaleBitMap(old->bm, (unsigned short) IEEEDPFix((IEEEDPFlt(old->treecontrol->Font->ta_YSize) / old->bm->height) * IEEEDPFlt(old->bm->width)), (unsigned short) old->treecontrol->Font->ta_YSize);
  463.             if (old->bm)
  464.                 old->flags |= TI_BITMAPISSCALED;
  465.         }
  466.         old->bmi = NULL;
  467.  
  468.         old->it.IText = (char *) GuiMalloc((strlen(text) + 1) * sizeof(char), 0);
  469.         if (old->it.IText)
  470.             strcpy(old->it.IText, text);
  471.         if ((!(old->parent)) || ItemIsOpen(old->parent))
  472.             DrawTreeItem(old, top, FALSE, FALSE);
  473.         TreeControlClipOff(old->treecontrol);
  474.         CheckCreateScrollers(old->treecontrol);
  475.         CheckDestroyScrollers(old->treecontrol);
  476.         if (oldIText)
  477.             GuiFree(oldIText);
  478.     }
  479.     return old;
  480. }
  481.  
  482. TreeItem* FOXLIB AddItem(REGA0 TreeControl *tc, REGA1 TreeItem *InsBefore, REGA2 TreeItem *Parent, REGA3 char *text,
  483.         REGD0 BOOL IsOpen, REGD1 GuiBitMap *bm, REGD2 void *ItemData)
  484. {
  485.     TreeItem *ti = (TreeItem *) GuiMalloc(sizeof(TreeItem), 0), *pp = Parent;
  486.  
  487.     if (ti)
  488.     {
  489.         BOOL draw = TRUE;
  490.  
  491.         ti->treecontrol = tc;
  492.         ti->itemdata = ItemData;
  493.         ti->flags = (IsOpen ? TI_OPEN : 0);
  494.         ti->parent = Parent;
  495.         ti->firstchild = NULL;
  496.         ti->plusminus = NULL;
  497.         ti->it.TopEdge = 0;
  498.         ti->it.NextText = NULL;
  499.         ti->it.ITextFont = tc->Font;
  500.         ti->it.FrontPen = tc->FrontPen;
  501.         ti->it.BackPen = GetBackCol(tc->WidgetData->Parent);
  502.         ti->it.DrawMode = JAM1;
  503.         ti->bm = bm;
  504.         if (ti->bm && ti->bm->height > tc->Font->ta_YSize)
  505.         {
  506.             /* The compiler should be clever enough to know that we're using Commodore IEEE DP Maths and insert all of the necessary
  507.                 conversions at compile time.  However, it can't manage the conversion from IEEE DP to unsigned short on it's own without
  508.                 generating a reference to __XCEXIT which we just can't allow in a shared library so I've helped it along a bit by inserting
  509.                 some of the conversions.  See Includes & Autodocs for a description of the IEEE DP conversions in the mathieeedoubbas
  510.                 library */
  511.             ti->bm = ScaleBitMap(ti->bm, (unsigned short) IEEEDPFix((IEEEDPFlt(tc->Font->ta_YSize) / ti->bm->height) * IEEEDPFlt(ti->bm->width)), tc->Font->ta_YSize);
  512.             if (ti->bm)
  513.                 ti->flags |= TI_BITMAPISSCALED;
  514.         }
  515.         ti->bmi = NULL;
  516.         ti->LineToParent.LeftEdge = /*tc->WidgetData->left +*/ 2 + tc->LBorder;
  517.         ti->LineToParent.TopEdge = /*tc->WidgetData->top +*/ 2 + tc->TBorder;
  518.         ti->LineToParent.DrawMode = JAM1;
  519.         ti->LineToParent.XY = ti->points;
  520.         ti->LineToParent.Count = 3;
  521.         ti->LineToParent.NextBorder = NULL;
  522.  
  523.         ti->it.IText = (char *) GuiMalloc((strlen(text) + 1) * sizeof(char), 0);
  524.         if (ti->it.IText)
  525.             strcpy(ti->it.IText, text);
  526.  
  527.         if (Parent)
  528.         {
  529.             // There's no need to redraw anything if the parent is closed UNLESS the parent is visible
  530.             // and this is the first child in which case the parent will need to be redrawn as the +/-
  531.             // button is created.
  532.             if (!ItemIsOpen(Parent) && !(Parent->firstchild == NULL &&
  533.                     (Parent->parent == NULL || ItemIsOpen(Parent->parent))))
  534.                 draw = FALSE;
  535.  
  536.             if (draw)
  537.             {
  538.                 while (pp->parent)
  539.                     pp = pp->parent;
  540.  
  541.                 TreeControlClipOn(tc);
  542.                 DrawTreeItem(pp, CalcItemTop(pp), TRUE, TRUE);
  543.             }
  544.  
  545.             ti->it.LeftEdge = Parent->it.LeftEdge + XOFFSET;
  546.             if (!Parent->firstchild)
  547.             {
  548.                 Parent->firstchild = ti;
  549.                 ti->next = NULL;
  550.             }
  551.             else // Parent already has a child.
  552.             {
  553.                 TreeItem *i = Parent->firstchild, *p = NULL;
  554.  
  555.                 while (i && i != InsBefore)
  556.                 {
  557.                     p = i;
  558.                     i = i->next;
  559.                 }
  560.                 if (i == Parent->firstchild)
  561.                     Parent->firstchild = ti;
  562.                 else
  563.                     p->next = ti;
  564.                 ti->next = i;
  565.             }
  566.  
  567.             if (draw)
  568.             {
  569.                 DrawTreeItem(pp, CalcItemTop(pp), TRUE, FALSE);
  570.                 TreeControlClipOff(tc);
  571.             }
  572.         }
  573.         else // No Parent
  574.         {
  575.             TreeItem *i = tc->itemlist, *p = NULL;
  576.             ti->it.LeftEdge = 0;
  577.  
  578.             if (i) // At least one item already in list
  579.             {
  580.                 while (i && i != InsBefore)
  581.                 {
  582.                     p = i;
  583.                     i = i->next;
  584.                 }
  585.  
  586.                 TreeControlClipOn(tc);
  587.                 DrawTreeItem(i, CalcItemTop(i), TRUE, TRUE);
  588.  
  589.                 ti->next = p->next;
  590.                 p->next = ti;
  591.             }
  592.             else // No items in list yet
  593.             {
  594.                 tc->itemlist = tc->topshown = ti;
  595.                 ti->next = NULL;
  596.  
  597.                 TreeControlClipOn(tc);
  598.             }
  599.             DrawTreeItem(ti, CalcItemTop(ti), TRUE, FALSE);
  600.             TreeControlClipOff(tc);
  601.         }
  602.         CheckCreateScrollers(tc);
  603.     }
  604.     return ti;
  605. }
  606.  
  607. __far __stdargs int PlusMinusButtonFn(PushButton *pb)
  608. {
  609.     TreeItem *ti = (TreeItem *) pb->WidgetData->ParentControl, *pp = ti;
  610.     TreeControl *tc = ti->treecontrol;
  611.     int top, retval = GUI_CONTINUE;
  612.  
  613.     if ((tc->WidgetData->flags & TC_OPENITEM) && !(ti->flags & TI_OPEN))
  614.         retval = ((TCIntFnPtr) *(tc->Eventfn))(tc, TC_OPENITEM, ti, NULL);
  615.     else if ((tc->WidgetData->flags & TC_CLOSEITEM) && (ti->flags & TI_OPEN))
  616.         retval = ((TCIntFnPtr) *(tc->Eventfn))(tc, TC_CLOSEITEM, ti, NULL);
  617.  
  618.     if (retval != GUI_END)
  619.     {
  620.         while (pp->parent)
  621.             pp = pp->parent;
  622.  
  623.         top = CalcItemTop(pp);
  624.  
  625.         TreeControlClipOn(tc);
  626.         DrawTreeItem(pp, top, TRUE, TRUE); // Will destroy the button.
  627.         if (ti->flags & TI_OPEN)
  628.             ti->flags &= ~TI_OPEN;
  629.         else
  630.             ti->flags |= TI_OPEN;
  631.  
  632.         DrawTreeItem(pp, top, TRUE, FALSE); // Will create the new button.
  633.         TreeControlClipOff(tc);
  634.  
  635.         if (ti->flags & TI_OPEN)
  636.             // We've just opened up a node - check whether we now need any scroll bars.
  637.             CheckCreateScrollers(tc);
  638.  
  639.         if ((tc->UD || tc->LR) && !(ti->flags & TI_OPEN))
  640.             // We've just closed a node - check whether we still need any scroll bars.
  641.             CheckDestroyScrollers(tc);
  642.     }
  643.     return retval;
  644. }
  645.  
  646. void FOXLIB OpenItem(REGA0 TreeItem *it)
  647. {
  648.     if (it && it->firstchild && !(it->flags & TI_OPEN))
  649.         PlusMinusButtonFn(it->plusminus);
  650. }
  651.  
  652. void FOXLIB CloseItem(REGA0 TreeItem *it)
  653. {
  654.     if (it && it->firstchild && (it->flags & TI_OPEN))
  655.         PlusMinusButtonFn(it->plusminus);
  656. }
  657.  
  658. static TreeItem *LV(int *top, TreeItem *ti)
  659. {
  660.     TreeItem *n = ti;
  661.  
  662.     // Need to multiply the font height by two because we are currently at the top of the
  663.     // previous item and we want to check the position of the bottom of the next item.
  664.     if (ti->firstchild && (ti->flags & TI_OPEN) && *top + (2 * ti->it.ITextFont->ta_YSize) < ti->treecontrol->WidgetData->height - 4 - (2 * ti->treecontrol->TBorder) - (ti->treecontrol->LR ? SCROLL_BUTTON_HEIGHT : 0))
  665.     {
  666.         *top += ti->it.ITextFont->ta_YSize;
  667.         n = LV(top, ti->firstchild);
  668.     }
  669.     if (ti->next && *top + (2 * ti->it.ITextFont->ta_YSize) < ti->treecontrol->WidgetData->height - 4 - (2 * ti->treecontrol->TBorder) - (ti->treecontrol->LR ? SCROLL_BUTTON_HEIGHT : 0))
  670.     {
  671.         *top += ti->it.ITextFont->ta_YSize;
  672.         n = LV(top, ti->next);
  673.     }
  674.     return n;
  675. }
  676.  
  677. static TreeItem *LowestVisible(TreeControl *tc)
  678. {
  679.     TreeItem *ti = tc->itemlist;
  680.     int top = CalcItemTop(ti);
  681.     return LV(&top, ti);
  682. }
  683.  
  684. static TreeItem *LastOpen(TreeControl *tc)
  685. {
  686.     TreeItem *t = tc->itemlist;
  687.  
  688.     if (t)
  689.     {
  690.         while (t->next)
  691.             t = t->next;
  692.         if ((t->flags & TI_OPEN) && t->firstchild)
  693.         {
  694.             t = t->firstchild;
  695.             while (t->next || (t->firstchild && (t->flags & TI_OPEN)))
  696.             {
  697.                 if (t->next)
  698.                     t = t->next;
  699.                 else
  700.                     t = t->firstchild;
  701.             }
  702.         }
  703.     }
  704.     return t;
  705. }
  706.  
  707. void TreeControlScrollDown(TreeControl *tc, BOOL RefreshScroller)
  708. {
  709.     int top = 0, maxlen = 0, maxtop = 0;
  710.     unsigned short body, pot;
  711.     // Find the bottom item shown:
  712.     TreeItem *newtop = NULL, *pp = tc->topshown;
  713.     BOOL ishi = (tc->topshown == tc->hiitem);
  714.  
  715.     if (LastOpen(tc) == LowestVisible(tc))
  716.         return; // Nothing open to scroll down to.
  717.  
  718.     if (tc->topshown->firstchild && (tc->topshown->flags & TI_OPEN))
  719.         newtop = tc->topshown->firstchild;
  720.     else if (tc->topshown->next)
  721.         newtop = tc->topshown->next;
  722.     else
  723.     {
  724.         TreeItem *ti = tc->topshown;
  725.  
  726.         while (ti->parent && !newtop)
  727.         {
  728.             ti = ti->parent;
  729.             if (ti->next)
  730.                 newtop = ti->next;
  731.         }
  732.  
  733.         if (!newtop) // nothing to scroll down to
  734.             return;
  735.     }
  736.  
  737.     TreeControlClipOn(tc);
  738.     while (pp->parent)
  739.         pp = pp->parent;
  740.     DrawTreeItem(pp, CalcItemTop(pp), TRUE, TRUE);
  741.     if (ishi && (tc->WidgetData->flags & TC_REHILIGHT_ON_SCROLL))
  742.     {
  743.         tc->hiitem->it.DrawMode = JAM1;
  744.         tc->hiitem = newtop;
  745.         tc->hiitem->it.DrawMode = JAM2 | INVERSVID;
  746.     }
  747.     tc->topshown = newtop;
  748.     DrawTreeItem(pp, CalcItemTop(pp), TRUE, FALSE);
  749.     TreeControlClipOff(tc);
  750.  
  751.     if (RefreshScroller)
  752.     {
  753.         FindMaxSizes(tc->itemlist, &maxlen, &maxtop, &top);
  754.         FindScrollerValues((maxtop + tc->Font->ta_YSize) / tc->Font->ta_YSize, (tc->WidgetData->height - 4 - (2 * tc->TBorder) - (tc->LR ? SCROLL_BUTTON_HEIGHT : 0)) / tc->Font->ta_YSize, (0 - CalcItemTop(tc->itemlist)) / tc->Font->ta_YSize, 1, &body, &pot);
  755.         NewModifyProp(&tc->UD->ScrollGad, tc->Win->Win, NULL, AUTOKNOB | FREEVERT | PROPNEWLOOK, 0, pot, 0, body, 1);
  756.     }
  757. }
  758.  
  759. int TCScrollDownButtFn(PushButton *pb)
  760. {
  761.     TreeControlScrollDown((TreeControl*) pb->WidgetData->ParentControl, TRUE);
  762.     return GUI_CONTINUE;
  763. }
  764.  
  765. void TreeControlScrollUp(TreeControl *tc, BOOL RefreshScroller)
  766. {
  767.     BOOL ishi = (LowestVisible(tc) == tc->hiitem);
  768.  
  769.     if (tc->itemlist != tc->topshown) // Already at the top?
  770.     {
  771.         int top = 0, maxlen = 0, maxtop = 0;
  772.         unsigned short body, pot;
  773.         TreeItem *p = FindPreviousItem(tc->topshown), *pp = tc->topshown;
  774.  
  775.         TreeControlClipOn(tc);
  776.         while (pp->parent)
  777.             pp = pp->parent;
  778.         DrawTreeItem(pp, CalcItemTop(pp), TRUE, TRUE);
  779.         tc->topshown = p;
  780.         if (ishi && (tc->WidgetData->flags & TC_REHILIGHT_ON_SCROLL))
  781.         {
  782.             tc->hiitem->it.DrawMode = JAM1;
  783.             tc->hiitem = LowestVisible(tc);
  784.             tc->hiitem->it.DrawMode = JAM2 | INVERSVID;
  785.         }
  786.         pp = p;
  787.         while (pp->parent)
  788.             pp = pp->parent;
  789.         DrawTreeItem(pp, CalcItemTop(pp), TRUE, FALSE);
  790.         TreeControlClipOff(tc);
  791.  
  792.         if (RefreshScroller)
  793.         {
  794.             FindMaxSizes(tc->itemlist, &maxlen, &maxtop, &top);
  795.             FindScrollerValues((maxtop + tc->Font->ta_YSize) / tc->Font->ta_YSize, (tc->WidgetData->height - 4 - (2 * tc->TBorder) - (tc->LR ? SCROLL_BUTTON_HEIGHT : 0)) / tc->Font->ta_YSize, (0 - CalcItemTop(tc->itemlist)) / tc->Font->ta_YSize, 1, &body, &pot);
  796.             NewModifyProp(&tc->UD->ScrollGad, tc->Win->Win, NULL, AUTOKNOB | FREEVERT | PROPNEWLOOK, 0, pot, 0, body, 1);
  797.         }
  798.     }
  799. }
  800.  
  801. int TCScrollUpButtFn(PushButton *pb)
  802. {
  803.     TreeControlScrollUp((TreeControl*) pb->WidgetData->ParentControl, TRUE);
  804.     return GUI_CONTINUE;
  805. }
  806.  
  807. TreeItem *FindItemByTop(TreeControl *tc, int top);
  808.  
  809. int TCScrollLeftButtFn(PushButton *pb)
  810. {
  811.     TreeControl *tc = (TreeControl *) pb->WidgetData->ParentControl;
  812.     int i;
  813.  
  814.     if (tc->xOffset < 0)
  815.     {
  816.         int top = 0, maxlen = 0, maxtop = 0, pptop;
  817.         unsigned short body, pot;
  818.         TreeItem *pp = tc->topshown;
  819.  
  820.         while (pp->parent)
  821.             pp = pp->parent;
  822.         pptop = CalcItemTop(pp);
  823.  
  824.         TreeControlClipOn(tc);
  825.         DrawTreeItem(pp, pptop, TRUE, TRUE);
  826.         tc->xOffset += tc->Font->ta_YSize;
  827.         if (tc->xOffset > 0)
  828.             tc->xOffset = 0;
  829.         FindMaxSizes(tc->itemlist, &maxlen, &maxtop, &top);
  830.         FindScrollerValues(maxlen, tc->WidgetData->width - 4 - (2 * tc->LBorder) - (tc->UD ? SCROLL_BUTTON_WIDTH : 0), 0 - tc->xOffset, tc->Font->ta_YSize, &body, &pot);
  831.         NewModifyProp(&tc->LR->ScrollGad, tc->Win->Win, NULL, AUTOKNOB | FREEHORIZ | PROPNEWLOOK, pot, 0, body, 0, 1);
  832.         DrawTreeItem(pp, pptop, TRUE, FALSE);
  833.         TreeControlClipOff(tc);
  834.     }
  835.     for (i = 0; i < 30; i++)
  836.         FindItemByTop(tc, i);
  837.     return GUI_CONTINUE;
  838. }
  839.  
  840. int TCScrollRightButtFn(PushButton *pb)
  841. {
  842.     int top = 0, maxlen = 0, maxtop = 0, pptop;
  843.     TreeControl *tc = (TreeControl *) pb->WidgetData->ParentControl;
  844.  
  845.     FindMaxSizes(tc->itemlist, &maxlen, &maxtop, &top);
  846.     if (tc->xOffset > tc->WidgetData->width - 4 - (2 * tc->LBorder) - (tc->UD ? SCROLL_BUTTON_WIDTH : 0) - maxlen)
  847.     {
  848.         unsigned short body, pot;
  849.         TreeItem *pp = tc->topshown;
  850.  
  851.         while (pp->parent)
  852.             pp = pp->parent;
  853.         pptop = CalcItemTop(pp);
  854.  
  855.         TreeControlClipOn(tc);
  856.         DrawTreeItem(pp, pptop, TRUE, TRUE);
  857.         tc->xOffset -= tc->Font->ta_YSize;
  858.         if (tc->xOffset < tc->WidgetData->width - 4 - (2 * tc->LBorder) - (tc->UD ? SCROLL_BUTTON_WIDTH : 0) - maxlen)
  859.             tc->xOffset = tc->WidgetData->width - 4 - (2 * tc->LBorder) - (tc->UD ? SCROLL_BUTTON_WIDTH : 0) - maxlen;
  860.         FindScrollerValues(maxlen, tc->WidgetData->width - 4 - (2 * tc->LBorder) - (tc->UD ? SCROLL_BUTTON_WIDTH : 0), 0 - tc->xOffset, tc->Font->ta_YSize, &body, &pot);
  861.         NewModifyProp(&tc->LR->ScrollGad, tc->Win->Win, NULL, AUTOKNOB | FREEHORIZ | PROPNEWLOOK, pot, 0, body, 0, 1);
  862.         DrawTreeItem(pp, pptop, TRUE, FALSE);
  863.         TreeControlClipOff(tc);
  864.     }
  865.     return GUI_CONTINUE;
  866. }
  867.  
  868. TreeItem* FOXLIB TCHiItem(REGA0 TreeControl *tc)
  869. {
  870.     if (tc)
  871.         if (tc->hiitem)
  872.             return tc->hiitem;
  873.     return NULL;
  874. }
  875.  
  876. char* FOXLIB TCHiText(REGA0 TreeControl *tc)
  877. {
  878.     if (tc)
  879.         if (tc->hiitem)
  880.             return tc->hiitem->it.IText;
  881.     return NULL;
  882. }
  883.  
  884. char* FOXLIB TCItemText(REGA0 TreeItem *ti)
  885. {
  886.     if (ti)
  887.         return ti->it.IText;
  888.     return NULL;
  889. }
  890.  
  891. TreeControl* FOXLIB MakeTreeControl(REGA0 void *Parent, REGD0 int left, REGD1 int top, REGD2 int width, REGD3 int height,
  892.         REGD4 int lborder, REGD5 int tborder, REGD6 int flags,
  893.         REGA1 int (* __far __stdargs Eventfn) (TreeControl*, short, TreeItem*, void**), REGA2 void *extension)
  894. {
  895.     TreeControl *tc;
  896.  
  897.     Diagnostic("MakeTreeControl", ENTER, TRUE);
  898.  
  899.     tc = (TreeControl *) CreateListBox(Parent, left, top, width, height, lborder, tborder,
  900.         Gui.TextCol, &GuiFont, (LBIntFnPtr) Eventfn, flags, TreeControlObjectType);
  901.  
  902.     Diagnostic("MakeTreeControl", EXIT, (tc != NULL));
  903.     return tc;
  904. }
  905.  
  906. void FOXLIB SetTreeControlDragPointer(REGA0 TreeControl *tc, REGA1 unsigned short *DragPointer, REGD0 int width, REGD1 int height,
  907.         REGD2 int xoffset, REGD3 int yoffset)
  908. {
  909.     if (tc)
  910.     {
  911.         tc->DragPointer = DragPointer;
  912.         tc->PointerWidth = width;
  913.         tc->PointerHeight = height;
  914.         tc->PointerXOffset = xoffset;
  915.         tc->PointerYOffset = yoffset;
  916.     }
  917.  
  918. }
  919.  
  920. static TreeItem *FindItemByTopRecurse(TreeItem *ti, int top, int *curtop)
  921. {
  922.     TreeItem *t = NULL;
  923.  
  924.     if (*curtop + ti->it.ITextFont->ta_YSize >= top)
  925.         return ti;
  926.  
  927.     if (ti->firstchild && (ti->flags & TI_OPEN))
  928.     {
  929.         *curtop += ti->it.ITextFont->ta_YSize;
  930.         t = FindItemByTopRecurse(ti->firstchild, top, curtop);
  931.         if (t)
  932.             return t;
  933.     }
  934.     if (ti->next)
  935.     {
  936.         *curtop += ti->it.ITextFont->ta_YSize;
  937.         t = FindItemByTopRecurse(ti->next, top, curtop);
  938.     }
  939.     return t;
  940. }
  941.  
  942. TreeItem *FindItemByTop(TreeControl *tc, int top)
  943. {
  944.     int curtop = 0;
  945.     TreeItem *ti;
  946.  
  947.     ti = FindItemByTopRecurse(tc->itemlist, top, &curtop);
  948.     return ti;
  949. }
  950.  
  951. void UpdateTCScrollGadImagery(TreeControl *tc)
  952. {
  953.     unsigned short top = 0;
  954.     int maxlen = 0, maxtop = 0, curtop = 0;
  955.  
  956.     FindMaxSizes(tc->itemlist, &maxlen, &maxtop, &curtop);
  957.  
  958.     if (tc->UD)
  959.     {
  960.         unsigned short curtop = (0 - CalcItemTop(tc->itemlist)) / tc->Font->ta_YSize;
  961.  
  962.         top = FindScrollerTop((maxtop + tc->Font->ta_YSize) / tc->Font->ta_YSize, (tc->WidgetData->height - 4 - (2 * tc->TBorder) - (tc->LR ? SCROLL_BUTTON_HEIGHT : 0)) / tc->Font->ta_YSize, tc->UD->ScrollGadInfo.VertPot);
  963.         if (top != curtop)
  964.         {
  965.             if (top == curtop - 1)
  966.                 TreeControlScrollUp(tc, FALSE);
  967.             else if (top == curtop + 1)
  968.                 TreeControlScrollDown(tc, FALSE);
  969.             else
  970.             {
  971.                 TreeItem *newtopitem, *pp = tc->topshown;
  972.                 int pixeltop = top * tc->Font->ta_YSize;
  973.                 BOOL HilightBottom = FALSE;
  974.  
  975.                 while (pp->parent)
  976.                     pp = pp->parent;
  977.                 TreeControlClipOn(tc);
  978.                 DrawTreeItem(pp, CalcItemTop(pp), TRUE, TRUE);
  979.                 newtopitem = FindItemByTop(tc, pixeltop);
  980.                 if (tc->hiitem && (tc->WidgetData->flags & TC_REHILIGHT_ON_SCROLL))
  981.                 {
  982.                     int newtopitemtop = CalcItemTop(newtopitem), hiitemtop = CalcItemTop(tc->hiitem);
  983.  
  984.                     if (top > curtop && hiitemtop >= curtop * tc->Font->ta_YSize && hiitemtop <=
  985.                             newtopitemtop)
  986.                     {
  987.                         tc->hiitem->it.DrawMode = JAM1;
  988.                         tc->hiitem = newtopitem;
  989.                         tc->hiitem->it.DrawMode = JAM2 | INVERSVID;
  990.                     }
  991.                     if (top < curtop && hiitemtop + ((curtop - top) * tc->Font->ta_YSize)
  992.                             >= (tc->WidgetData->height - 4 - (2 * tc->TBorder) - (tc->LR ? SCROLL_BUTTON_HEIGHT : 0)))
  993.                     {
  994.                         tc->hiitem->it.DrawMode = JAM1;
  995.                         HilightBottom = TRUE;
  996.                     }
  997.                 }
  998.                 pp = tc->topshown = newtopitem;
  999.                 if (HilightBottom)
  1000.                 {
  1001.                     tc->hiitem = LowestVisible(tc); // New Bottom Item
  1002.                     tc->hiitem->it.DrawMode = JAM2 | INVERSVID;
  1003.                 }
  1004.                 while (pp->parent)
  1005.                     pp = pp->parent;
  1006.                 DrawTreeItem(pp, CalcItemTop(pp), TRUE, FALSE);
  1007.                 TreeControlClipOff(tc);
  1008.             }
  1009.         }
  1010.     }
  1011.     if (tc->LR)
  1012.     {
  1013.         int left = 0 - FindScrollerTop(maxlen, tc->WidgetData->width - 4 - (2 * tc->LBorder), tc->LR->ScrollGadInfo.HorizPot);
  1014.         if (left != tc->xOffset) // Horizontal Scroller
  1015.         {
  1016.             TreeItem *pp = tc->topshown;
  1017.             int pptop;
  1018.  
  1019.             while (pp->parent)
  1020.                 pp = pp->parent;
  1021.             pptop = CalcItemTop(pp);
  1022.             TreeControlClipOn(tc);
  1023.             DrawTreeItem(pp, pptop, TRUE, TRUE);
  1024.             tc->xOffset = left;
  1025.             DrawTreeItem(pp, pptop, TRUE, FALSE);
  1026.             TreeControlClipOff(tc);
  1027.         }
  1028.     }
  1029. }
  1030.  
  1031. void TreeControlRehilight(TreeControl *tc, TreeItem *HiElem, BOOL unhilight, BOOL hilight)
  1032. {
  1033.     // If the element has not been specified then unhilight only.
  1034.  
  1035.     if (hilight || unhilight)
  1036.         TreeControlClipOn(tc);
  1037.  
  1038.     // Unhilight previous selection
  1039.     if (tc->hiitem)
  1040.     {
  1041.         BOOL parentisopen = ((tc->hiitem->parent && ItemIsOpen(tc->hiitem->parent)) || !tc->hiitem->parent);
  1042.         TreeItem *ti = tc->hiitem;
  1043.         int hitop = CalcItemTop(ti);
  1044.  
  1045.         if (unhilight && tc->hidden == 0 && parentisopen)
  1046.             DrawTreeItem(ti, hitop, FALSE, TRUE);
  1047.  
  1048.         tc->hiitem = NULL;
  1049.         ti->it.DrawMode = JAM1;
  1050.         if (unhilight && tc->hidden == 0 && parentisopen)
  1051.             DrawTreeItem(ti, hitop, FALSE, FALSE);
  1052.     }
  1053.  
  1054.     // Now hilight the new item...
  1055.     if (HiElem)
  1056.     {
  1057.         BOOL parentisopen = ((HiElem->parent && ItemIsOpen(HiElem->parent)) || !HiElem->parent);
  1058.         int newhitop = CalcItemTop(HiElem);
  1059.  
  1060.         if (hilight && tc->hidden == 0 && parentisopen)
  1061.             DrawTreeItem(HiElem, newhitop, FALSE, TRUE);
  1062.  
  1063.         tc->hiitem = HiElem;
  1064.         tc->hiitem->it.DrawMode = JAM2 | INVERSVID;
  1065.         if (hilight && tc->hidden == 0 && parentisopen)
  1066.             DrawTreeItem(tc->hiitem, newhitop, FALSE, FALSE);
  1067.     }
  1068.     if (hilight || unhilight)
  1069.         TreeControlClipOff(tc);
  1070. }
  1071.  
  1072. // This function is called by FoxGui to unhilight an item that the pointer was held over
  1073. // when the user was dragging something into this tree control, without hilighting another item.
  1074. void ClearTreeControlDropNum(TreeControl *tc, TreeItem *OldHiItem)
  1075. {
  1076.     TreeControlClipOn(tc);
  1077.  
  1078.     // Unhilight previous selection
  1079.     if (OldHiItem && OldHiItem != tc->hiitem)
  1080.     {
  1081.         BOOL parentisopen = ((OldHiItem->parent && ItemIsOpen(OldHiItem->parent)) || !OldHiItem->parent);
  1082.         TreeItem *ti = OldHiItem;
  1083.         int hitop = CalcItemTop(ti);
  1084.  
  1085.         if (tc->hidden == 0 && parentisopen)
  1086.             DrawTreeItem(ti, hitop, FALSE, TRUE);
  1087.  
  1088.         ti->it.DrawMode = JAM1;
  1089.         if (tc->hidden == 0 && parentisopen)
  1090.             DrawTreeItem(ti, hitop, FALSE, FALSE);
  1091.     }
  1092.     TreeControlClipOff(tc);
  1093. }
  1094.  
  1095. // This function is called by FoxGui to hilight the item that the pointer is held over
  1096. // when the user is dragging something into this treecontrol.
  1097. TreeItem *SetTreeControlDropNum(TreeControl *tc, TreeItem *HiItem, TreeItem *OldHiItem)
  1098. {
  1099.     if (HiItem == OldHiItem)
  1100.         return HiItem; // Nothing to do.
  1101.  
  1102.     TreeControlClipOn(tc);
  1103.  
  1104.     // Unhilight previous selection
  1105.     if (OldHiItem && OldHiItem != tc->hiitem)
  1106.     {
  1107.         BOOL parentisopen = ((OldHiItem->parent && ItemIsOpen(OldHiItem->parent)) || !OldHiItem->parent);
  1108.         TreeItem *ti = OldHiItem;
  1109.         int hitop = CalcItemTop(ti);
  1110.  
  1111.         if (tc->hidden == 0 && parentisopen)
  1112.             DrawTreeItem(ti, hitop, FALSE, TRUE);
  1113.  
  1114.         ti->it.DrawMode = JAM1;
  1115.         if (tc->hidden == 0 && parentisopen)
  1116.             DrawTreeItem(ti, hitop, FALSE, FALSE);
  1117.     }
  1118.  
  1119.     // Now hilight the new item...
  1120.     if (HiItem && HiItem != tc->hiitem)
  1121.     {
  1122.         BOOL parentisopen = ((HiItem->parent && ItemIsOpen(HiItem->parent)) || !HiItem->parent);
  1123.         int newhitop = CalcItemTop(HiItem);
  1124.  
  1125.         if (tc->hidden == 0 && parentisopen)
  1126.             DrawTreeItem(HiItem, newhitop, FALSE, TRUE);
  1127.  
  1128.         HiItem->it.DrawMode = JAM2 | INVERSVID;
  1129.         if (tc->hidden == 0 && parentisopen)
  1130.             DrawTreeItem(HiItem, newhitop, FALSE, FALSE);
  1131.     }
  1132.     TreeControlClipOff(tc);
  1133.     return HiItem;
  1134. }
  1135.  
  1136. void FOXLIB SetTreeControlHiItem(REGA0 TreeControl *tc, REGA1 TreeItem *HiItem, REGD0 BOOL refresh)
  1137. {
  1138.     TreeControlRehilight(tc, HiItem, refresh, refresh);
  1139. }
  1140.  
  1141. int TCSelect(TreeControl *tc, long x, long y, unsigned long seconds, unsigned long micros, Frame **FrameDownPtr)
  1142.     {
  1143.     static unsigned long last_seconds = 0;
  1144.     static unsigned long last_micros = 0;
  1145.     static TreeItem *last_selected = NULL;
  1146.  
  1147.     if (tc)
  1148.         {
  1149.         TreeItem *SelectedElem;
  1150.  
  1151.         y -= tc->WidgetData->top + tc->TBorder + 1;
  1152.  
  1153.         SelectedElem = FindItemByTop(tc, y - CalcItemTop(tc->itemlist));
  1154.         if (SelectedElem)
  1155.             {
  1156.             TreeControlRehilight(tc, SelectedElem, TRUE, TRUE);
  1157.  
  1158.             /*    Is this the second click of a double-click?  (If it is but the list-box has no
  1159.                 double-click function then treat this as a second single-click). */
  1160.             if ((tc->WidgetData->flags & TC_DBLCLICK) && tc->Eventfn &&
  1161.                         DoubleClick(last_seconds, last_micros, seconds, micros) &&
  1162.                         SelectedElem == last_selected)
  1163.                 {
  1164.                 // This is the second click of a double click.
  1165.                 int Stop;
  1166.                 last_selected = NULL;
  1167.                 *FrameDownPtr = NULL;
  1168.                 Stop = ((TCIntFnPtr) *(tc->Eventfn))(tc, TC_DBLCLICK, tc->hiitem, NULL);
  1169.                 return Stop;
  1170.                 }
  1171.             else // This is a single click.
  1172.                 {
  1173.                 last_seconds = seconds;
  1174.                 last_micros = micros;
  1175.                 last_selected = SelectedElem;
  1176.                 if ((tc->WidgetData->flags & TC_SELECT) && tc->Eventfn)
  1177.                     {
  1178.                     int Stop;
  1179.                     *FrameDownPtr = NULL;
  1180.                     Stop = ((TCIntFnPtr) *(tc->Eventfn))(tc, TC_SELECT, tc->hiitem, NULL);
  1181.                     return Stop;
  1182.                     }
  1183.                 }
  1184.             }
  1185.         }
  1186.     return GUI_CONTINUE;
  1187.     }
  1188.  
  1189. void FOXLIB ClearTreeControl(REGA0 TreeControl *tc)
  1190. {
  1191.     if (tc)
  1192.     {
  1193.         if (tc->itemlist)
  1194.             FreeItemTree(tc->itemlist, NULL, TRUE);
  1195.         tc->itemlist = tc->topshown = tc->hiitem = NULL;
  1196.  
  1197.         if (tc->LR)
  1198.             DestroyHorizontalScroller(tc, FALSE);
  1199.         if (tc->UD)
  1200.             DestroyVerticalScroller(tc, FALSE);
  1201.         ListBoxRefresh(tc);
  1202.     }
  1203. }
  1204.  
  1205. void* FOXLIB ItemData(REGA0 TreeItem *ti)
  1206. {
  1207.     return ti->itemdata;
  1208. }
  1209.  
  1210. void UndrawTreeControl(TreeControl *tc)
  1211. {
  1212.     TreeControlClipOn(tc);
  1213.     DrawTreeItem(tc->itemlist, CalcItemTop(tc->itemlist), TRUE, TRUE);
  1214.     TreeControlClipOff(tc);
  1215. }
  1216.  
  1217. void DrawTreeControl(TreeControl *tc)
  1218. {
  1219.     ListBoxRefresh(tc);
  1220.     TreeControlClipOn(tc);
  1221.     DrawTreeItem(tc->itemlist, CalcItemTop(tc->itemlist), TRUE, FALSE);
  1222.     TreeControlClipOff(tc);
  1223. }
  1224.